home *** CD-ROM | disk | FTP | other *** search
/ ftp.hitl.washington.edu / ftp.hitl.washington.edu.tar / ftp.hitl.washington.edu / pub / people / tsoper / CT Explorer / Sensor.cs < prev    next >
Text File  |  2005-05-23  |  11KB  |  386 lines
  1. //Sensor.cs
  2. //
  3. //    The Sensor class is responsble for setting and getting all parameters from the 
  4. //  PCI board as well as printing the values.
  5.  
  6. using System;
  7. using System.Windows.Forms;
  8.  
  9. namespace PCIBird
  10. {
  11.     /// <summary>
  12.     /// Summary description for Sensor.
  13.     /// </summary>
  14.     public class Sensor
  15.     {
  16.  
  17.         public DataFormatParameter DataFormat;
  18.         public AngleAlignParameter AngleAlign;
  19.         public HemisphereParameter Hemisphere;
  20.         public FilterACWideNotchParameter FilterACWideNotch;
  21.         public FilterACNarrowNotchParameter FilterACNarrowNotch;
  22.         public FilterDCAdaptiveParameter FilterDCAdaptive;
  23.         public FilterAlphaParameters FilterAlpha;  //Parameters (plural)
  24.         public FilterLargeChangeParameter FilterLargeChange;
  25.         public QualityParams Quality; //Params used b/c QualityParameters already used
  26.         public SerialNumberRXParameter SerialNumberRX;
  27.  
  28.         public PCIBirdWrapper pciBird;
  29.         public ushort id;
  30.  
  31.             //overloaded constructors
  32.         public Sensor()
  33.         {
  34.             //create wrapper library
  35.             pciBird = new PCIBirdWrapper();
  36.             id = 0; //initialize id to 0
  37.             LoadParameters();
  38.         }
  39.         public Sensor(ushort ID)
  40.         {
  41.             //create wrapper library
  42.             pciBird = new PCIBirdWrapper();
  43.             id = ID;
  44.             LoadParameters();
  45.         }
  46.         public Sensor(ushort ID, PCIBirdWrapper pciBirdWrapper)
  47.         {
  48.             //create wrapper library
  49.             pciBird = pciBirdWrapper;
  50.             id = ID;
  51.             LoadParameters();
  52.         }
  53.  
  54.  
  55.             
  56.         private void LoadParameters()
  57.         {
  58.             //instantiate parameters
  59.             DataFormat = new DataFormatParameter(id,pciBird);
  60.             AngleAlign = new AngleAlignParameter(id,pciBird);
  61.             Hemisphere = new HemisphereParameter(id,pciBird);
  62.             FilterACWideNotch = new FilterACWideNotchParameter(id,pciBird);
  63.             FilterACNarrowNotch = new FilterACNarrowNotchParameter(id,pciBird);
  64.             FilterDCAdaptive = new FilterDCAdaptiveParameter(id,pciBird);
  65.             FilterAlpha = new FilterAlphaParameters(id,pciBird);
  66.             FilterLargeChange = new FilterLargeChangeParameter(id,pciBird);
  67.             Quality = new QualityParams(id,pciBird);
  68.             SerialNumberRX = new SerialNumberRXParameter(id,pciBird);
  69.         }
  70.  
  71.         public SensorConfig GetSensorConfig()
  72.         {
  73.             return pciBird.GetSensorConfig(id);
  74.         }
  75.  
  76.         public PositionAnglesReading GetAsyncReading()
  77.         {
  78.             PositionAnglesReading par = new PositionAnglesReading();
  79.             pciBird.GetAsyncSensorReading(id,par,48);
  80.             return par;
  81.         }
  82.  
  83.         public void PrintSensorConfig( RichTextBox rtb )
  84.         {
  85.             //get the configuration
  86.             SensorConfig sc = GetSensorConfig();
  87.  
  88.             string configStr =    "\n\nSENSOR " + id + " CONFIGURATION:\n" + 
  89.                                 "Serial Number:    " + sc.serialNumber + "\n" +
  90.                                 "Board Number:    " + sc.boardNumber + "\n" +
  91.                                 "Channel Number:    " + sc.channelNumber + "\n" +
  92.                                 "Type:        " + sc.type + "\n" +
  93.                                 "Attached        " + sc.attached + "\n";
  94.             
  95.  
  96.             rtb.AppendText(configStr);
  97.         }
  98.  
  99.         public void PrintSensorParameters( RichTextBox rtb )
  100.         {
  101.             string alphaMaxStr = "";
  102.             string alphaMinStr = "";
  103.             string vmStr = "";
  104.             for(int i = 0; i < 7; i++)
  105.             {
  106.                 alphaMaxStr = alphaMaxStr + this.FilterAlpha.Get().alphaMax[i] + "    ";
  107.                 alphaMinStr = alphaMinStr + this.FilterAlpha.Get().alphaMin[i] + "    ";
  108.                 vmStr = vmStr + this.FilterAlpha.Get().vm[i] + "    ";
  109.             }
  110.  
  111.             string paramStr =    "\n\nSENSOR " + id + " PARAMETERS:\n" +
  112.                                 "Data Format:        "    + this.DataFormat.Get() + "\n" + 
  113.                                 "Angle Align:    " + "    azimuth:" + this.AngleAlign.Get().a + 
  114.                                                     "    elevation:" + this.AngleAlign.Get().e +            
  115.                                                     "    roll:" + this.AngleAlign.Get().r + "\n" +
  116.                                 "Hemisphere:        " + this.Hemisphere.Get() + "\n" +
  117.                                 "Filter AC Wide Notch:    " + this.FilterACWideNotch.Get() + "\n" +
  118.                                 "Filter AC Narrow Notch:    " + this.FilterACNarrowNotch.Get() + "\n" +
  119.                                 "Filter DC Adaptive:        " + this.FilterDCAdaptive.Get() + "\n" +
  120.                                 "Filter Alpha Parameters:\n" +    "    Alpha Min:    " + alphaMinStr + "\n" +
  121.                                                                 "    Alpha Max:    " + alphaMaxStr + "\n" + 
  122.                                                                 "    vm:        "    + vmStr + "\n" +
  123.                                 "Filter Large Change:        " + this.FilterLargeChange.Get() + "\n" +
  124.                                 "Quality:            " + "slope:" + this.Quality.Get().errorSlope + "     " +
  125.                                                 "offset:" + this.Quality.Get().errorOffset + "     " +
  126.                                             "sensitivity:" + this.Quality.Get().errorSensitivity + "     " +
  127.                                                 "Filter Alpha:"    + this.Quality.Get().filterAlpha + "\n" +
  128.                                 "Serial Number:        " + this.SerialNumberRX.Get();
  129.                 
  130.  
  131.  
  132.             rtb.AppendText(paramStr);
  133.  
  134.         }
  135.  
  136. /************************ PARAMETER CLASSES ***********************************/
  137.  
  138.         //   DATA FORMAT PARAMETER----------------------------
  139.         public class DataFormatParameter
  140.         {
  141.             private ushort id;
  142.             private PCIBirdWrapper pciBird;
  143.             public DataFormatParameter(ushort ID, PCIBirdWrapper pciBirdWrapper)
  144.             {
  145.                 id = ID;
  146.                 pciBird = pciBirdWrapper;
  147.             }
  148.  
  149.             public DATA_FORMAT_TYPE Get()
  150.             {
  151.                 object o = new int();
  152.                 pciBird.GetSensorParam(id,SENSOR_PARAMETER_TYPE.DATA_FORMAT, o, 4);
  153.                 return (DATA_FORMAT_TYPE) Convert.ToInt32(o);
  154.             }
  155.  
  156.             public void Set(DATA_FORMAT_TYPE dft)
  157.             {
  158.                 pciBird.SetSensorParam(id,SENSOR_PARAMETER_TYPE.DATA_FORMAT,(int)dft,4);
  159.                 return;
  160.             }
  161.         }
  162.  
  163.         //   ANGLE ALIGN PARAMETER----------------------------
  164.         public class AngleAlignParameter
  165.         {
  166.             private ushort id;
  167.             private PCIBirdWrapper pciBird;
  168.             public AngleAlignParameter(ushort ID, PCIBirdWrapper pciBirdWrapper)
  169.             {
  170.                 id = ID;
  171.                 pciBird = pciBirdWrapper;
  172.             }
  173.  
  174.             public AnglesReading Get()
  175.             {
  176.                 AnglesReading angleAlign = new AnglesReading();
  177.                 pciBird.GetSensorParam(id,SENSOR_PARAMETER_TYPE.ANGLE_ALIGN, angleAlign,24);
  178.                 return angleAlign;
  179.             }
  180.  
  181.             public void Set(AnglesReading angleAlign)
  182.             {
  183.                 pciBird.SetSensorParam(id,SENSOR_PARAMETER_TYPE.ANGLE_ALIGN,angleAlign,24);
  184.                 return;
  185.             }
  186.         }
  187.  
  188.         //   HEMISPHERE PARAMETER----------------------------
  189.         public class HemisphereParameter
  190.         {
  191.             private ushort id;
  192.             private PCIBirdWrapper pciBird;
  193.             public HemisphereParameter(ushort ID, PCIBirdWrapper pciBirdWrapper)
  194.             {
  195.                 id = ID;
  196.                 pciBird = pciBirdWrapper;
  197.             }
  198.  
  199.             public HEMISPHERE_TYPE Get()
  200.             {
  201.                 object o = new int();
  202.                 pciBird.GetSensorParam(id,SENSOR_PARAMETER_TYPE.HEMISPHERE,o,4);
  203.                 return (HEMISPHERE_TYPE) Convert.ToInt32(o);
  204.             }
  205.  
  206.             public void Set(HEMISPHERE_TYPE ht)
  207.             {
  208.                 pciBird.SetSensorParam(id,SENSOR_PARAMETER_TYPE.HEMISPHERE,(int)ht,4);
  209.                 return;
  210.             }
  211.         }
  212.  
  213.         //   FILTER AC WIDE NOTCH PARAMETER----------------------------
  214.         public class FilterACWideNotchParameter
  215.         {
  216.             private ushort id;
  217.             private PCIBirdWrapper pciBird;
  218.             public FilterACWideNotchParameter(ushort ID, PCIBirdWrapper pciBirdWrapper)
  219.             {
  220.                 id = ID;
  221.                 pciBird = pciBirdWrapper;
  222.             }
  223.  
  224.             public bool Get()
  225.             {
  226.                 object o = new int();
  227.                 pciBird.GetSensorParam(id,SENSOR_PARAMETER_TYPE.FILTER_AC_WIDE_NOTCH,o,4);
  228.                 return Convert.ToBoolean(o);
  229.             }
  230.  
  231.             public void Set(bool torf)
  232.             {
  233.                 int buffer = torf.CompareTo(false); //cast bool to int
  234.                 pciBird.SetSensorParam(id,SENSOR_PARAMETER_TYPE.FILTER_AC_WIDE_NOTCH,buffer,4);
  235.                 return;
  236.             }
  237.         }
  238.  
  239.         //   FILTER AC NARROW NOTCH PARAMETER----------------------------
  240.         public class FilterACNarrowNotchParameter
  241.         {
  242.             private ushort id;
  243.             private PCIBirdWrapper pciBird;
  244.             public FilterACNarrowNotchParameter(ushort ID, PCIBirdWrapper pciBirdWrapper)
  245.             {
  246.                 id = ID;
  247.                 pciBird = pciBirdWrapper;
  248.             }
  249.  
  250.             public bool Get()
  251.             {
  252.                 object o = new int();
  253.                 pciBird.GetSensorParam(id,SENSOR_PARAMETER_TYPE.FILTER_AC_NARROW_NOTCH,o,4);
  254.                 return Convert.ToBoolean(o);
  255.             }
  256.  
  257.             public void Set(bool torf)
  258.             {
  259.                 int buffer = torf.CompareTo(false); //cast bool to int
  260.                 pciBird.SetSensorParam(id,SENSOR_PARAMETER_TYPE.FILTER_AC_NARROW_NOTCH,buffer,4);
  261.                 return;
  262.             }
  263.         }
  264.  
  265.         //   FILTER DC ADAPTIVE PARAMETER----------------------------
  266.         public class FilterDCAdaptiveParameter
  267.         {
  268.             private ushort id;
  269.             private PCIBirdWrapper pciBird;
  270.             public FilterDCAdaptiveParameter(ushort ID, PCIBirdWrapper pciBirdWrapper)
  271.             {
  272.                 id = ID;
  273.                 pciBird = pciBirdWrapper;
  274.             }
  275.  
  276.             public double Get()
  277.             {
  278.                 object o = new double();
  279.                 pciBird.GetSensorParam(id,SENSOR_PARAMETER_TYPE.FILTER_DC_ADAPTIVE,o,8);
  280.                 return Convert.ToDouble(o);
  281.             }
  282.  
  283.             public void Set(double dca)
  284.             {
  285.                 pciBird.SetSensorParam(id,SENSOR_PARAMETER_TYPE.FILTER_DC_ADAPTIVE,dca,8);
  286.                 return;
  287.             }
  288.         }
  289.  
  290.         //   FILTER ALPHA PARAMETERS----------------------------
  291.         public class FilterAlphaParameters
  292.         {
  293.             private ushort id;
  294.             private PCIBirdWrapper pciBird;
  295.             public FilterAlphaParameters(ushort ID, PCIBirdWrapper pciBirdWrapper)
  296.             {
  297.                 id = ID;
  298.                 pciBird = pciBirdWrapper;
  299.             }
  300.  
  301.             public AdaptiveParameters Get()
  302.             {
  303.                 AdaptiveParameters alpha = new AdaptiveParameters();
  304.                 pciBird.GetSensorParam(id,SENSOR_PARAMETER_TYPE.FILTER_ALPHA_PARAMETERS,alpha,48);
  305.                 return alpha;
  306.             }
  307.  
  308.             public void Set(AdaptiveParameters alpha)
  309.             {
  310.                 pciBird.SetSensorParam(id,SENSOR_PARAMETER_TYPE.FILTER_ALPHA_PARAMETERS,alpha,48);
  311.                 return;
  312.             }
  313.         }
  314.  
  315.         //   FILTER LARGE CHANGE PARAMETER----------------------------
  316.         public class FilterLargeChangeParameter
  317.         {
  318.             private ushort id;
  319.             private PCIBirdWrapper pciBird;
  320.             public FilterLargeChangeParameter(ushort ID, PCIBirdWrapper pciBirdWrapper)
  321.             {
  322.                 id = ID;
  323.                 pciBird = pciBirdWrapper;
  324.             }
  325.  
  326.             public bool Get()
  327.             {
  328.                 object o = new int();
  329.                 pciBird.GetSensorParam(id,SENSOR_PARAMETER_TYPE.FILTER_LARGE_CHANGE,o,4);
  330.                 return Convert.ToBoolean(o);
  331.             }
  332.  
  333.             public void Set(bool torf)
  334.             {
  335.                 int buffer = torf.CompareTo(false); //cast bool to int
  336.                 pciBird.SetSensorParam(id,SENSOR_PARAMETER_TYPE.FILTER_AC_NARROW_NOTCH,buffer,4);
  337.                 return;
  338.             }
  339.         }
  340.  
  341.         //   QUALITY PARAMETERS----------------------------
  342.         public class QualityParams
  343.         {
  344.             private ushort id;
  345.             private PCIBirdWrapper pciBird;
  346.             public QualityParams(ushort ID, PCIBirdWrapper pciBirdWrapper)
  347.             {
  348.                 id = ID;
  349.                 pciBird = pciBirdWrapper;
  350.             }
  351.  
  352.             public QualityParameters Get()
  353.             {
  354.                 QualityParameters qp = new QualityParameters();
  355.                 pciBird.GetSensorParam(id,SENSOR_PARAMETER_TYPE.QUALITY,qp,8);
  356.                 return qp;
  357.             }
  358.  
  359.             public void Set(QualityParameters qp)
  360.             {
  361.                 pciBird.SetSensorParam(id,SENSOR_PARAMETER_TYPE.QUALITY,qp,8);
  362.                 return;
  363.             }
  364.         }
  365.  
  366.         //   SERIAL NUMBER RX PARAMETER----------------------------
  367.         public class SerialNumberRXParameter
  368.         {
  369.             private ushort id;
  370.             private PCIBirdWrapper pciBird;
  371.             public SerialNumberRXParameter(ushort ID, PCIBirdWrapper pciBirdWrapper)
  372.             {
  373.                 id = ID;
  374.                 pciBird = pciBirdWrapper;
  375.             }
  376.  
  377.             public int Get()
  378.             {
  379.                 object o = new int();
  380.                 pciBird.GetSensorParam(id,SENSOR_PARAMETER_TYPE.SERIAL_NUMBER_RX,o,4);
  381.                 return Convert.ToInt32(o);
  382.             }
  383.         }
  384.     }
  385. }
  386.